// 导入API模块
const api = require('../../../api/index');

Page({
  data: {
    // 从源码获取的详细MBTI测试题库
    allQuestions: [
      {
        desc: "今年五一，出去旅游的话，你会",
        planA: "规划好路线，每天的流程也安排好",
        planB: "放假拎包就走，不规划，看心情",
        valA: "J",
        valB: "P"
      },
      {
        desc: "你觉得自己是个什么性格的人",
        planA: "一个性格较为随和、没有明确的目标和计划的人可能会随心所欲地行动。[e.g. 李白]",
        planB: "一个性格较为有条理的人可能会比较注重计划和安排，更容易按部就班地完成自己的任务。[e.g. 徐霞客]",
        valA: "P",
        valB: "J"
      },
      {
        desc: "如果你是学者或研究者，你会探索什么",
        planA: "自然科学领域中的物理学[e.g. 牛顿]",
        planB: "哲学领域[e.g. 柏拉图]",
        valA: "S",
        valB: "N"
      },
      {
        desc: "你是个开朗，自来熟的人吗",
        planA: "是",
        planB: "不是",
        valA: "E",
        valB: "I"
      },
      {
        desc: "你容易和下面哪些人交朋友？",
        planA: "天马行空的艺术家",
        planB: "实事求是的企业家",
        valA: "N",
        valB: "S"
      },
      {
        desc: "你比较",
        planA: "感性",
        planB: "理性",
        valA: "F",
        valB: "T"
      },
      {
        desc: "工作生活中，你",
        planA: "常常凭借自己的冲动和热情来做出决定",
        planB: "具有系统的组织能力和理性思维，在行动前会制定详细的计划和时间表",
        valA: "P",
        valB: "J"
      },
      {
        desc: "你内心的情绪想法是否挂在脸上",
        planA: "是",
        planB: "不是",
        valA: "E",
        valB: "I"
      },
      {
        desc: "按照详细的计划和时间表，并一步一步地执行",
        planA: "令你感到稳妥",
        planB: "令你感到束缚",
        valA: "J",
        valB: "P"
      },
      {
        desc: "当你去执行某任务时",
        planA: "制定计划来预防或减轻问题",
        planB: "更加喜欢实时应对问题",
        valA: "J",
        valB: "P"
      },
      {
        desc: "在大多数情况下，你会选择",
        planA: "在行动前会，制定详细的计划和时间表",
        planB: "喜欢实际行动和经验，实时应对问题",
        valA: "P",
        valB: "J"
      },
      {
        desc: "你在朋友眼中是个注重保护个人信息和隐私的人吗",
        planA: "是的",
        planB: "不是",
        valA: "I",
        valB: "E"
      },
      {
        desc: "你觉得朋友眼中的你是个",
        planA: "务实的人",
        planB: "思维活跃的人",
        valA: "S",
        valB: "N"
      },
      {
        desc: "遇到朋友和他的朋友，你会",
        planA: "自我介绍",
        planB: "沉默，待朋友介绍你",
        valA: "E",
        valB: "I"
      },
      {
        desc: "你觉得身边朋友",
        planA: "思维活跃，富有想象力",
        planB: "脚踏实地的，实事求是",
        valA: "N",
        valB: "S"
      },
      {
        desc: "你做事",
        planA: "比较激情感性",
        planB: "重逻辑有条理",
        valA: "F",
        valB: "T"
      },
      {
        desc: "你比较喜欢",
        planA: "实时应当",
        planB: "末雨绸缪",
        valA: "F",
        valB: "J"
      },
      {
        desc: "你平时喜欢独处吗",
        planA: "喜欢",
        planB: "不喜欢",
        valA: "I",
        valB: "E"
      },
      {
        desc: "酒吧舞会中，你会感到",
        planA: "激情活力",
        planB: "嘈杂，想安静",
        valA: "E",
        valB: "I"
      },
      {
        desc: "去游乐场，你会",
        planA: "提前按计划把要玩的项目安排妥当",
        planB: "没有计划，随心想玩就玩",
        valA: "J",
        valB: "P"
      },
      {
        desc: "去旅游",
        planA: "人到，随心逛",
        planB: "有规划，按部就班",
        valA: "P",
        valB: "J"
      },
      {
        desc: "你乐于社交聚会吗",
        planA: "不，想独处",
        planB: "是，乐在其中",
        valA: "I",
        valB: "E"
      },
      {
        desc: "朋友认为你",
        planA: "平易近人",
        planB: "高冷",
        valA: "E",
        valB: "I"
      },
      {
        desc: "你更崇拜",
        planA: "思维活跃，富有想象力的人",
        planB: "见多识广，经验丰富的人",
        valA: "N",
        valB: "S"
      },
      {
        desc: "在生活工作中，你会",
        planA: "在执行时才思考解决方法",
        planB: "提前做好计划，条理进行",
        valA: "P",
        valB: "J"
      },
      {
        desc: "你觉得自己是有城府的人吗",
        planA: "是",
        planB: "不是",
        valA: "I",
        valB: "E"
      },
      {
        desc: "以下选项组合中，您更倾向于哪个选项，来表达个人的个性、风格及偏好？",
        planA: "看重隐私，不会用来换取便利",
        planB: "可能会为一些便利，舍弃一些隐私",
        valA: "I",
        valB: "E"
      },
      {
        desc: "以下选项组合中，您更倾向于哪个选项，来表达个人的个性、风格及偏好？",
        planA: "对未来有规划",
        planB: "遇事再解决",
        valA: "J",
        valB: "P"
      }
    ],
    questions: [], // 当前测试版本的问题
    currentIndex: 0,
    selectedOption: null,
    answers: [],
    dimensionScores: {
      E: 0, I: 0,
      S: 0, N: 0,
      T: 0, F: 0,
      J: 0, P: 0
    },
    questionCount: 0,
    versionName: "",
    versionId: "", // 添加版本ID
    userId: "", // 添加用户ID
    // 添加双击相关变量
    lastTapTime: 0,
    lastTapValue: "",
    doubleClickThreshold: 1000 // 双击间隔阈值，单位为毫秒，设置为1秒
  },
  
  onLoad: function(options) {
    wx.setNavigationBarTitle({
      title: 'MBTI测试中'
    });
    
    const versionIndex = parseInt(options.version || 0);
    let questionCount = 28; // 默认使用简洁版
    let versionId = options.versionId || "simple_v1"; // 使用从mbti.js传过来的versionId，如果没有则使用默认值
    let userId = options.userId || ""; // 从mbti.js传过来的userId
    
    // 根据版本设置问题数量和版本名称
    switch(versionIndex) {
      case 0: // 简洁版
        questionCount = 28;
        this.setData({ versionName: "简洁版" });
        break;
      case 1: // 通用版
        questionCount = 48;
        this.setData({ versionName: "通用版" });
        break;
      case 2: // 完整版
        questionCount = Math.min(93, this.data.allQuestions.length);
        this.setData({ versionName: "完整版" });
        break;
    }
    
    // 使用前questionCount个问题
    const selectedQuestions = this.data.allQuestions.slice(0, questionCount);
    
    // 初始化答案数组
    let initialAnswers = new Array(selectedQuestions.length).fill(null);
    this.setData({
      questions: selectedQuestions,
      answers: initialAnswers,
      questionCount: selectedQuestions.length,
      versionId: versionId,
      userId: userId // 保存userId
    });

    // 获取用户ID（如果需要）
    if (!userId) {
      this.getUserId();
    } else {
      // 如果已有userId，直接提交版本信息
      this.saveVersionInfo();
    }
  },

  // 获取用户ID并提交到API
  getUserId: function() {
    const app = getApp();
    let userId = "";
    
    // 尝试从全局获取用户ID
    if (app.globalData && app.globalData.userId) {
      userId = app.globalData.userId;
    } else if (app.globalData && app.globalData.userInfo && app.globalData.userInfo.userId) {
      userId = app.globalData.userInfo.userId;
    } else {
      // 如果全局没有，从存储中获取
      try {
        const userInfo = wx.getStorageSync('userInfo');
        if (userInfo && userInfo.userId) {
          userId = userInfo.userId;
        }
      } catch(e) {
        console.error('获取用户信息失败:', e);
      }
    }
    
    // 如果没有用户ID，生成一个临时ID
    if (!userId) {
      userId = 'temp_' + Date.now() + '_' + Math.floor(Math.random() * 10000);
      // 如果有全局对象，保存到全局
      if (app.globalData) {
        app.globalData.userId = userId;
      }
      // 保存到本地存储
      try {
        wx.setStorageSync('userInfo', { userId: userId });
      } catch(e) {
        console.error('保存用户信息失败:', e);
      }
    }
    
    this.setData({ userId: userId });
    
    // 提交用户ID和版本信息到API
    this.saveVersionInfo();
  },
  
  // 提交版本信息到API (使用API模块)
  saveVersionInfo: function() {
    const { userId, versionId, versionName } = this.data;
    
    console.log('尝试提交MBTI测试版本信息:', {userId: userId, versionId: versionId, versionName: versionName});
    
    // 调用API模块方法
    api.mbti.submitVersionInfo(userId, versionId, versionName)
      .then(result => {
        if (result && result.success === false) {
          console.warn('MBTI测试版本提交返回失败:', result.message);
        } else {
          console.log('MBTI测试版本提交成功');
        }
      })
      .catch(error => {
        console.error('MBTI测试版本提交失败:', error);
        // 由于这是非关键功能，即使失败也继续测试流程
      });
  },
  
  selectOption: function(e) {
    const value = e.currentTarget.dataset.value;
    this.setData({
      selectedOption: value
    });
  },
  
  // 新增：处理触摸开始
  handleTouchStart: function(e) {
    const nowTime = new Date().getTime();
    const value = e.currentTarget.dataset.value;
    
    // 检测是否为双击
    if (nowTime - this.data.lastTapTime < this.data.doubleClickThreshold && value === this.data.lastTapValue) {
      // 是双击，选中并前往下一题
      this.selectAndNext(e);
    } else {
      // 记录本次点击
      this.setData({
        lastTapTime: nowTime,
        lastTapValue: value
      });
    }
    // 不阻止事件冒泡，允许bindtap事件正常触发
  },
  
  // 新增：选中并前往下一题
  selectAndNext: function(e) {
    const value = e.currentTarget.dataset.value;
    
    // 先选中选项
    this.setData({
      selectedOption: value
    }, () => {
      // 然后前往下一题
      this.nextQuestion();
    });
  },
  
  prevQuestion: function() {
    if (this.data.currentIndex > 0) {
      const newIndex = this.data.currentIndex - 1;
      this.setData({
        currentIndex: newIndex,
        selectedOption: this.data.answers[newIndex]
      });
    }
  },
  
  nextQuestion: function() {
    if (!this.data.selectedOption) {
      wx.showToast({
        title: '请选择一个选项',
        icon: 'none'
      });
      return;
    }
    
    // 保存当前答案
    let newAnswers = [...this.data.answers];
    newAnswers[this.data.currentIndex] = this.data.selectedOption;
    
    // 更新维度得分
    const currentQuestion = this.data.questions[this.data.currentIndex];
    const selectedValue = this.data.selectedOption;
    let newDimensionScores = {...this.data.dimensionScores};
    newDimensionScores[selectedValue]++;
    
    this.setData({
      answers: newAnswers,
      dimensionScores: newDimensionScores
    });
    
    if (this.data.currentIndex < this.data.questions.length - 1) {
      // 前往下一题
      const newIndex = this.data.currentIndex + 1;
      this.setData({
        currentIndex: newIndex,
        selectedOption: this.data.answers[newIndex]
      });
    } else {
      // 完成测试，计算结果
      this.calculateResult();
    }
  },
  
  calculateResult: function() {
    const { dimensionScores, versionId, userId } = this.data;
    
    // 判断每个维度的倾向
    const personality = [
      dimensionScores.E > dimensionScores.I ? 'E' : 'I',
      dimensionScores.S > dimensionScores.N ? 'S' : 'N',
      dimensionScores.T > dimensionScores.F ? 'T' : 'F',
      dimensionScores.J > dimensionScores.P ? 'J' : 'P'
    ].join('');
    
    // 计算每个维度的百分比
    const percentages = {
      EI: Math.round((dimensionScores.E / (dimensionScores.E + dimensionScores.I)) * 100),
      SN: Math.round((dimensionScores.S / (dimensionScores.S + dimensionScores.N)) * 100),
      TF: Math.round((dimensionScores.T / (dimensionScores.T + dimensionScores.F)) * 100),
      JP: Math.round((dimensionScores.J / (dimensionScores.J + dimensionScores.P)) * 100)
    };
    
    // 显示提交提示
    wx.showToast({
      title: '提交答案中...',
      icon: 'loading',
      duration: 1500
    });
    
    // 提交测试结果到API (使用API模块)
    this.submitTestResult(personality, {
      E: dimensionScores.E,
      I: dimensionScores.I,
      S: dimensionScores.S,
      N: dimensionScores.N,
      T: dimensionScores.T,
      F: dimensionScores.F,
      J: dimensionScores.J,
      P: dimensionScores.P
    });
    
    // 延迟跳转，等待提交完成
    setTimeout(() => {
      // 跳转到结果页
      wx.navigateTo({
        url: `/pages/mbti/result/result?type=${personality}&ei=${percentages.EI}&sn=${percentages.SN}&tf=${percentages.TF}&jp=${percentages.JP}&versionId=${versionId}&userId=${userId}`
      });
    }, 1000);
  },
  
  // 完成测试时的处理，添加API调用
  completeTest: function() {
    const { dimensionScores, answers, questions, versionId, userId } = this.data;
    
    // 重置得分
    let scores = {
      E: 0, I: 0,
      S: 0, N: 0,
      T: 0, F: 0,
      J: 0, P: 0
    };
    
    // 统计得分
    for (let i = 0; i < answers.length; i++) {
      if (answers[i] !== null) {
        const question = questions[i];
        const selectedValue = answers[i] === 'A' ? question.valA : question.valB;
        scores[selectedValue]++;
      }
    }
    
    // 计算各项得分百分比
    const eiTotal = scores.E + scores.I;
    const snTotal = scores.S + scores.N;
    const tfTotal = scores.T + scores.F;
    const jpTotal = scores.J + scores.P;
    
    const eiPercent = eiTotal === 0 ? 50 : Math.round((scores.E / eiTotal) * 100);
    const snPercent = snTotal === 0 ? 50 : Math.round((scores.S / snTotal) * 100);
    const tfPercent = tfTotal === 0 ? 50 : Math.round((scores.T / tfTotal) * 100);
    const jpPercent = jpTotal === 0 ? 50 : Math.round((scores.J / jpTotal) * 100);
    
    // 确定人格类型
    const personalityType = 
      (eiPercent >= 50 ? 'E' : 'I') +
      (snPercent >= 50 ? 'S' : 'N') +
      (tfPercent >= 50 ? 'T' : 'F') +
      (jpPercent >= 50 ? 'J' : 'P');
    
    console.log('MBTI类型:', personalityType);
    console.log('得分详情:', scores);
    
    // 创建得分详情对象用于API提交
    const scoreDetails = {
      E: scores.E,
      I: scores.I,
      S: scores.S,
      N: scores.N,
      T: scores.T,
      F: scores.F,
      J: scores.J,
      P: scores.P
    };
    
    // 显示提交提示
    wx.showToast({
      title: '提交答案中...',
      icon: 'loading',
      duration: 1500
    });
    
    // 提交测试结果到API (使用API模块)
    this.submitTestResult(personalityType, scoreDetails);
    
    // 延迟跳转，等待提交完成
    setTimeout(() => {
      // 跳转到结果页面，并传递versionId和userId
      wx.redirectTo({
        url: `/pages/mbti/result/result?type=${personalityType}&ei=${eiPercent}&sn=${snPercent}&tf=${tfPercent}&jp=${jpPercent}&versionId=${versionId}&userId=${userId}`
      });
    }, 1000);
  },
  
  // 提交测试结果到API (使用API模块)
  submitTestResult: function(mbtiType, scoreDetails) {
    const userId = this.data.userId;
    const versionId = this.data.versionId;
    
    console.log('尝试提交MBTI测试结果:', { userId, mbtiType, versionId });
    
    // 调用API模块方法
    api.mbti.submitTestResult(userId, mbtiType, scoreDetails, versionId)
      .then(result => {
        if (result && result.success === false) {
          console.warn('MBTI测试结果提交返回失败:', result.message);
          wx.showToast({
            title: '提交失败',
            icon: 'error',
            duration: 1500
          });
        } else {
          console.log('MBTI测试结果提交成功');
          wx.showToast({
            title: '提交成功',
            icon: 'success',
            duration: 1500
          });
        }
      })
      .catch(error => {
        console.error('MBTI测试结果提交失败:', error);
        wx.showToast({
          title: '网络波动，请稍后',
          icon: 'error',
          duration: 1500
        });
      });
  },
}) 